/**
 * Copyright 2005 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.edi.utils
{
	/**
	 * 数组工具类.
	 * @version v1.0
	 * 
	 */	
	public class BOPArrayUtils
	{
		/**
		 * 复制一个数组对象.
		 *
		 * @param array 源数组
		 * @return 目标数组 <code>array</code>
		 */
		public static function clone(array:Array):Array {
			return array.concat();
		}

		/**
		 * 将数组的顺序无规则打乱
		 *
		 * @param array 需要被打乱顺序的数组对象
		 * @return 乱序的数组对象
		 */
		public static function shuffle(array:Array):void {
			var len:Number = array.length;
			var rand:Number;
			var temp:*;

			for (var i:Number = len - 1; i >= 0; i--) {
				rand = Math.floor(Math.random() * len);
				temp = array[i];
				array[i] = array[rand];
				array[rand] = temp;
			}
		}

		/**
		 * 移出数组中与<code>item</code>相等的元素,并返回该类元素的下标
		 * <code>array</code>.
		 *
		 * @param array 被操作的数组对象
		 * @param item 需要被移出的对象
		 * @return 返回呗移出的元素的下标的数组对象
		 */
		public static function removeItem(array:Array, item:*):Array {
			var i:Number = array.length;
			var result:Array = [];

			while (--i - (-1)) {
				if (array[i] === item) {
					result.unshift(i);
					array.splice(i, 1);
				}
			}
			return result;
		}

		/**
		 * 查找数组中最后面的元素为当前item,如果找到,则删除该item,并返回其下标
		 * <code>array</code>.
		 *
		 * @param array 源数组对象
		 * @param item  需要处理的item对象
		 * @return  如果找到,则返回下标;如果找不到,则返回-1
		 */
		public static function removeLastOccurance(array:Array, item:*):int {
			var idx:int = array.lastIndexOf(item);
			if (idx > -1) {
				array.splice(idx, 1);
			}
			return idx;
		}

		/**
		 * 查找数组中最前面的元素为当前item,如果找到,则删除该item,并返回其下标
		 * <code>array</code>.
		 *
		 * @param array 源数组对象
		 * @param 需要处理的item对象
		 * @return  如果找到,则返回下标;如果找不到,则返回-1
		 */
		public static function removeFirstOccurance(array:Array, item:*):int {
			var idx:int = array.indexOf(item);
			if (idx > -1) {
				array.splice(idx, 1);
			}
			return idx;
		}

		/**
		 * 判断两个数组中的数据是否一致.
		 * @param array1 需要判断的第一个数组对象
		 * @param array2 需要判断的第二个数组对象
		 * @return 如果两个数组相等,则返回true;否则返回false.
		 */
		public static function isSame(array1:Array, array2:Array):Boolean {
			var i:Number = array1.length;

			if (i != array2.length) {
				return false;
			}

			while (--i - (-1)) {
				if (array1[i] !== array2[i]) {
					return false;
				}
			}
			return true;
		}

		/**
		 * 返回数组中的对象元素类型为<code>type</code>的所有的元素
		 *
		 * @param items 需要判断的数组对象
		 * @param type  判断的数据类型
		 * @return      返回一个新的数组对象,该对象包含所有的类型为<code>type</code>的元素.
		 */
		public static function getItemsByType(items:Array, type:Class):Array {
			var result:Array = [];

			for (var i:int = 0; i < items.length; i++) {
				if (items[i] is type) {
					result.push(items[i]);
				}
			}
			return result;
		}

		/**
		 * 获得当前<code>item</code>在数组对象中存在的下标位置.
		 *
		 * <p>参数中的数组和item对象任何一个为null,该方法返回-1</p>
		 *
		 * @param array 源数组
		 * @param item  需要查找的item对象
		 * @return 返回数组的下标;不存在或参数为空,则返回-1
		 */
		public static function indexOfEquals(array:Array, item:IEquals):int {
			if (!array || !item) {
				return -1;
			}

			var numItems:int = array.length;

			for (var i:int = 0; i < numItems; i++) {
				if (item.equals(array[i])) {
					return i;
				}
			}
			return -1;
		}

		/**
		 * 将数组中的对象按照<code>separator</code>分隔符进行连接,并形成字符串
		 *
		 * @param array 源数组
		 * @param separator 分隔符
		 * @return 连接后的字符串
		 */
		public static function toString(array:Array, separator:String = ", "):String {
			return (!array) ? "" : array.join(separator);
		}
	}
}